/* @ 数组去重
题目解读：
    去除数组中重复的元素。
    即：
        const arr = [1, 1, '1', 17, true, true, false, false, 'true', 'a', {}, {}];
        // => [1, '1', 17, true, false, 'true', 'a', {}, {}]
**/

// --- 原数组
const arr = [1, 1, '1', 17, true, true, false, false, 'true', 'a', {}, {}];


/* 方法一：使用 Set
    Set类
        ES6 提供了新的数据结构 Set。它类似于数组，但是成员的值都是唯一的，没有重复的值。
    参考连接：《简书 —— JS之Set数据结构》
        https://www.jianshu.com/p/80bf2e6139dc
*/
const res1 = Array.from(new Set(arr));


/* 方法二：利用 Map
    Map 对象
        定义 键/值对的集合，集合中的键和值可以是任何类型。
        如果使用现有密钥向集合添加值，则新值会替换旧值。
    参考连接：《简书 —— Js中的Map对象简介》
        https://www.jianshu.com/p/ab6a62ca5fb0
*/
const unique5 = arr => {
    const map = new Map();
    const res = [];
    for (let i = 0; i < arr.length; i++) {
        if (!map.has(arr[i])) {
            map.set(arr[i], true);
            res.push(arr[i]);
        }
    }
    return res;
}


/* 方法三：利用 include
    JavaScript Array includes() 方法
        includes() 方法用来判断一个数组是否包含一个指定的值，
        如果是返回 true，否则false。
    语法：
        arr.includes(searchElement)
        arr.includes(searchElement, fromIndex)

        -- 如果 fromIndex 为负值，计算出的索引将作为开始搜索searchElement的位置。
           如果计算出的索引小于 0，则整个数组都会被搜索。
    示例：
        [1, 2, 3].includes(2);     // true
        [1, 2, 3].includes(4);     // false
        [1, 2, 3].includes(3, 3);  // false
        [1, 2, 3].includes(3, -1); // true
        [1, 2, NaN].includes(NaN); // true
*/
const unique3 = arr => {
    const res = [];
    for (let i = 0; i < arr.length; i++) {
        if (!res.includes(arr[i])) res.push(arr[i]);
    }
    return res;
}


/* 方法四：利用 filter
    filter 方法
*/
const unique4 = arr => {
    return arr.filter((item, index) => {
        return arr.indexOf(item) === index;
    });
}


/* 方法五：利用 indexOf

*/
const unique2 = arr => {
    const res = [];
    for (let i = 0; i < arr.length; i++) {
        if (res.indexOf(arr[i]) === -1) res.push(arr[i]);
    }
    return res;
}


/* 方法六：两层 for循环 + splice

*/
const unique1 = arr => {
    let len = arr.length;
    for (let i = 0; i < len; i++) {
        for (let j = i + 1; j < len; j++) {
            if (arr[i] === arr[j]) {
                arr.splice(j, 1);
                // 每删除一个树，j--保证j的值经过自加后不变。同时，len--，减少循环次数提升性能
                len--;
                j--;
            }
        }
    }
    return arr;
}

